How AgentFlo Scaled AI-Driven Commerce Agents Using Amazon Bedrock AgentCore and the Strands Agents SDK
In the rapidly evolving landscape of digital commerce, customer expectations have shifted toward instantaneous, personalized, and conversational interactions. Yet, despite trillions of dollars passing through online channels annually, the global cart abandonment rate stubbornly hovers around 70 percent. For merchants utilizing messaging platforms like WhatsApp, SMS, and web chat, this friction is exacerbated by the limitations of traditional infrastructure. Rule-based chatbots often fail when confronted with nuanced sales inquiries, while human customer service agents cannot cost-effectively scale across multiple geographies, languages, and time zones.
To bridge this gap, Salesflo developed AgentFlo, an agentic commerce service designed to deploy always-on artificial intelligence sales, support, and ordering agents. Serving eCommerce merchants managing over $300 billion in annual transacted value across platforms such as Shopify, WooCommerce, Magento, and SAP, AgentFlo converts conversational interactions into completed transactions. To achieve the velocity, standardization, and scalability required for production environments, AgentFlo leveraged Amazon Bedrock AgentCore and the Strands Agents SDK, building a robust, serverless architecture on Amazon Web Services (AWS).
The Technical Architecture of Production-Grade AI Agents
Building a demo agent capable of handling basic queries is relatively straightforward; however, orchestrating an autonomous system that safely manages financial transactions, inventory checks, and customer data at scale requires a fundamentally different architectural paradigm. AgentFlo addresses this challenge through a production-grade framework divided into five core pillars: Velocity, Standardization, Scalability, Trust, and Reliability. The first installment of this two-part architectural series focuses on the initial three pillars.
At the core of AgentFlo’s platform is a sophisticated AWS-native infrastructure designed to handle high-concurrency messaging without latency degradation. Customer messages originating from WhatsApp via the Graph API or web chat interfaces first pass through an Application Load Balancer. They are then ingested by an AWS Fargate messaging layer responsible for essential preprocessing tasks, including authentication, optical character recognition (OCR) for product images, speech-to-text and text-to-speech conversions, and pre-turn security evaluations designed to detect prompt injection attacks.
Validated requests flow directly into the Amazon Bedrock AgentCore runtime, where the Strands Agents SDK orchestrates an agent that streams model inference to an external large language model (LLM). Concurrently, AgentCore Gateway manages tool calls via Identity and Access Management (IAM) authorization, routing them to an API layer comprised of AWS Lambda functions dedicated to cart management, product catalogs, and knowledge retrieval.
State persistence is maintained across a resilient data layer. Session and cart data reside in Amazon DynamoDB tables, order records are stored in Amazon Aurora, and an Amazon Bedrock Knowledge Base backed by Amazon S3 handles retrieval-augmented generation (RAG) tasks. Furthermore, fine-grained access control is enforced independently of model reasoning via policy guardrails in Amazon Bedrock, ensuring strict adherence to enterprise security protocols. Observability is maintained through integrated logging and tracing via AgentCore Observability, while Amazon Data Firehose captures every interaction into Amazon S3 for comprehensive cost and revenue analytics.
Pillar 1: Velocity and Recipe-Based Deployment
Speed to market is a critical metric for modern merchants seeking to capture emerging consumer trends and seasonal opportunities. However, providing rapid deployment options while accommodating the unique workflows, brand voices, product catalogs, and multilingual requirements of diverse merchants presents a significant engineering hurdle. Generic chatbot templates lack the necessary depth, while bespoke custom builds fail to scale economically.
To resolve this dichotomy, AgentFlo implemented a recipe-based deployment model. Merchants select from a curated library of pre-configured operational templates—ranging from sales and restaurant ordering to clinic reception—within the AgentFlo Portal. Each recipe includes predefined personas, linguistic parameters, tone guidelines, tool sets, prompt templates, and business rules.
Underpinning this rapid deployment model is the Strands Agents SDK, which utilizes a model-driven architecture. Developers define tools as standard Python functions and establish system prompts, allowing the underlying model to manage orchestration without the need for rigid workflow graphs or hand-coded state machines. Consequently, when a merchant customizes an agent through the portal, an automated backend pipeline provisions a dedicated Strands Agent instance, maps tool definitions to AgentCore Gateway endpoints, and establishes a live production endpoint. This modularity ensures that adding advanced capabilities, such as loyalty program integration, requires only a simple function update rather than an architectural rewrite.
Pillar 2: Standardization Through Centralized Tool Routing
As AgentFlo expanded its footprint across multiple industries, architectural fragmentation threatened to impede operational efficiency. Because every merchant utilizes disparate enterprise resource planning (ERP) systems, pricing matrices, and regional localization protocols, standardizing the underlying infrastructure was paramount.
Rather than deploying complex multi-agent systems—which often introduce coordination overhead and context degradation—AgentFlo adopted a single-agent architecture enriched with domain-specific knowledge. Each deployed agent maintains a unified, persistent context throughout the conversation, outperforming multi-agent frameworks in conversion metrics. When conversational handoffs are necessary, such as transitioning from a sales inquiry to technical support, context is securely transferred to a specialized agent.
Integration standardization is achieved primarily through the AgentCore Gateway, which acts as a centralized integration backbone for third-party commerce platforms. By defining each integration as a Model Context Protocol (MCP) server connector, AgentFlo abstracts away the underlying complexities of OAuth credential management and platform-specific API communication. Platform credentials and API keys are stored securely within the Gateway, shielding them from individual agent sessions. Furthermore, fine-grained, Cedar-based authorization policies operate independently of model reasoning, ensuring that specific agent sessions are strictly limited to authorized toolsets.
Pillar 3: Elastic Scalability for Unpredictable Commerce Volumes
Commerce traffic is inherently volatile, subject to sudden traffic surges driven by flash sales, product drops, and regional peak hours. During such events, customer engagement volumes can spike exponentially, demanding an infrastructure capable of elastic scaling without manual administrative intervention.
AgentFlo meets this requirement through a fully serverless architecture implemented on AWS, where message ingestion, agent execution, tool processing, and state management scale independently. A cornerstone of this scalability is the Amazon Bedrock AgentCore runtime, which provides several distinct technical advantages:
- Isolated MicroVM Execution: Each customer session runs within a dedicated, lightweight virtual microVM equipped with isolated CPU, memory, and filesystem resources. Upon session termination, the environment is sanitized, completely eliminating cross-merchant interference.
- Long-Running Stateful Sessions: Agent sessions remain active and stateful for up to eight hours, enabling consumers to seamlessly resume conversations across multiple visits without losing contextual history or cart status.
- Framework Agnosticism: While natively optimized for the Strands Agents SDK, the runtime supports containerized agent frameworks, offering long-term architectural flexibility.
Implications and Future Outlook
The deployment of autonomous, AI-driven commerce agents signifies a major maturation point for conversational artificial intelligence. By decoupling model orchestration from secure tool execution and leveraging serverless microVM environments, AgentFlo has demonstrated a viable blueprint for operating high-stakes, transactional AI systems at enterprise scale.
As digital storefronts increasingly migrate toward conversational interfaces across platforms like WhatsApp and RCS, the ability to maintain contextual memory, enforce deterministic guardrails, and execute backend commerce workflows securely will define market leadership. Part two of this architectural series will examine the remaining pillars of production-grade AI agents—focusing on trust, reliability, and measurable business outcomes across the customer lifecycle.
